package no.nordicsemi.android.nrfmesh.utils;

import android.util.Log;
import java.util.ArrayList;
import java.util.List;

/**
 * 阻抗数据过滤器
 * 用于过滤掉无效的0值阻抗数据，确保统计计算的准确性
 */
public class ImpedanceDataFilter {
    private static final String TAG = "ImpedanceDataFilter";
    
    /**
     * 过滤掉无效的阻抗数据（0值）
     * @param impedanceList 原始阻抗数据列表
     * @return 过滤后的有效阻抗数据列表
     */
    public static List<Float> filterValidImpedanceData(List<Float> impedanceList) {
        if (impedanceList == null || impedanceList.isEmpty()) {
            Log.d(TAG, "输入的阻抗列表为空");
            return new ArrayList<>();
        }
        
        List<Float> validData = new ArrayList<>();
        int filteredCount = 0;
        
        for (Float impedance : impedanceList) {
            if (impedance != null && impedance > 0) {
                validData.add(impedance);
            } else {
                filteredCount++;
                Log.d(TAG, "过滤掉无效阻抗值: " + impedance);
            }
        }
        
        Log.d(TAG, "原始数据: " + impedanceList.size() + " 个, 有效数据: " + 
              validData.size() + " 个, 过滤掉: " + filteredCount + " 个");
        
        return validData;
    }
    
    /**
     * 检查阻抗值是否有效
     * @param impedance 阻抗值
     * @return true表示有效，false表示无效
     */
    public static boolean isValidImpedance(Float impedance) {
        return impedance != null && impedance > 0;
    }
    
    /**
     * 计算有效阻抗数据的平均值
     * @param impedanceList 阻抗数据列表
     * @return 平均值，如果没有有效数据则返回0
     */
    public static float calculateValidAverage(List<Float> impedanceList) {
        List<Float> validData = filterValidImpedanceData(impedanceList);
        if (validData.isEmpty()) {
            Log.d(TAG, "没有有效的阻抗数据用于计算平均值");
            return 0;
        }
        
        float sum = 0;
        for (Float value : validData) {
            sum += value;
        }
        
        float average = sum / validData.size();
        Log.d(TAG, "计算有效阻抗平均值: " + average + " Ω");
        return average;
    }
    
    /**
     * 计算有效阻抗数据的最大值
     * @param impedanceList 阻抗数据列表
     * @return 最大值，如果没有有效数据则返回0
     */
    public static float calculateValidMax(List<Float> impedanceList) {
        List<Float> validData = filterValidImpedanceData(impedanceList);
        if (validData.isEmpty()) {
            Log.d(TAG, "没有有效的阻抗数据用于计算最大值");
            return 0;
        }
        
        float max = validData.get(0);
        for (Float value : validData) {
            if (value > max) {
                max = value;
            }
        }
        
        Log.d(TAG, "计算有效阻抗最大值: " + max + " Ω");
        return max;
    }
    
    /**
     * 计算有效阻抗数据的最小值
     * @param impedanceList 阻抗数据列表
     * @return 最小值，如果没有有效数据则返回0
     */
    public static float calculateValidMin(List<Float> impedanceList) {
        List<Float> validData = filterValidImpedanceData(impedanceList);
        if (validData.isEmpty()) {
            Log.d(TAG, "没有有效的阻抗数据用于计算最小值");
            return 0;
        }
        
        float min = validData.get(0);
        for (Float value : validData) {
            if (value < min) {
                min = value;
            }
        }
        
        Log.d(TAG, "计算有效阻抗最小值: " + min + " Ω");
        return min;
    }
}